/**
 * 格式验证规则
 */
import { ValidationResult } from '../types';
import dayjs from 'dayjs';

/**
 * 邮箱验证规则选项接口
 */
export interface EmailValidationOptions {
  // 邮箱验证不需要额外选项
}

/**
 * 手机号验证规则选项接口
 */
export interface PhoneValidationOptions {
  // 手机号验证不需要额外选项
}

/**
 * 身份证验证规则选项接口
 */
export interface IdCardValidationOptions {
  // 身份证验证不需要额外选项
}

/**
 * URL验证规则选项接口
 */
export interface UrlValidationOptions {
  // URL验证不需要额外选项
}

/**
 * IP地址验证规则选项接口
 * @property {('v4' | 'v6')} [version] IP地址版本，可选值：'v4'、'v6'（可选，默认为同时支持v4和v6）
 */
export interface IpValidationOptions {
  /**
   * IP地址版本，可选值：'v4'、'v6'（可选，默认为同时支持v4和v6）
   */
  version?: 'v4' | 'v6';
}

/**
 * 日期/时间验证规则选项接口
 */
export interface DateTimeValidationOptions {
  // 不需要额外选项
}

/**
 * 正则表达式验证规则选项接口
 * @property {RegExp} pattern - 用于验证的正则表达式模式
 */
export interface PatternValidationOptions {
  /**
   * 用于验证的正则表达式模式
   */
  pattern: RegExp;
}

/**
 * 邮箱验证规则
 * @param {any} value - 要验证的值
 * @returns {ValidationResult} 验证结果
 * @example
 * // 直接调用
 * const result = validateEmail('test@example.com');
 * console.log(result); // { valid: true, message: undefined }
 * 
 * // 使用validateRule
 * const ruleResult = validateRule('invalid-email', { type: 'email' });
 * console.log(ruleResult); // { valid: false, message: '请输入有效的邮箱地址' }
 */
export function validateEmail(value: any): ValidationResult {
  const emailPattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
  const isValid = typeof value === 'string' && emailPattern.test(value);
  return {
    valid: isValid,
    message: isValid ? undefined : '请输入有效的邮箱地址'
  };
}

/**
 * 手机号验证规则
 * @param {any} value - 要验证的值
 * @returns {ValidationResult} 验证结果
 * @example
 * // 直接调用
 * const result = validatePhone('13812345678');
 * console.log(result); // { valid: true, message: undefined }
 * 
 * // 使用validateRule
 * const ruleResult = validateRule('123456789', { type: 'phone' });
 * console.log(ruleResult); // { valid: false, message: '请输入有效的手机号码' }
 */
export function validatePhone(value: any): ValidationResult {
  // 中国大陆手机号正则表达式（支持13-19开头的手机号）
  const phonePattern = /^1[3-9]\d{9}$/;
  const isValid = typeof value === 'string' && phonePattern.test(value);
  return {
    valid: isValid,
    message: isValid ? undefined : '请输入有效的手机号码'
  };
}

/**
 * 身份证验证规则
 * @param {any} value - 要验证的值
 * @returns {ValidationResult} 验证结果
 * @example
 * // 直接调用
 * const result = validateIdCard('110101199001011234');
 * console.log(result); // { valid: true, message: undefined }
 * 
 * // 使用validateRule
 * const ruleResult = validateRule('123456789012345678', { type: 'idCard' });
 * console.log(ruleResult); // { valid: false, message: '请输入有效的身份证号码' }
 */
export function validateIdCard(value: any): ValidationResult {
  // 中国大陆18位身份证号码验证正则表达式
  // 包含省份代码、出生日期、顺序码和校验码的基本格式验证
  const idCardPattern = /^[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[\dXx]$/;
  const isValid = typeof value === 'string' && idCardPattern.test(value);
  return {
    valid: isValid,
    message: isValid ? undefined : '请输入有效的身份证号码'
  };
}

/**
 * URL验证规则
 * @param {any} value - 要验证的值
 * @returns {ValidationResult} 验证结果
 * @example
 * // 直接调用
 * const result = validateUrl('https://www.example.com');
 * console.log(result); // { valid: true, message: undefined }
 * 
 * // 使用validateRule
 * const ruleResult = validateRule('invalid-url', { type: 'url' });
 * console.log(ruleResult); // { valid: false, message: '请输入有效的URL地址' }
 */
export function validateUrl(value: any): ValidationResult {
  // URL验证正则表达式，支持http、https和ftp协议
  const urlPattern = /^(https?:\/\/|ftp:\/\/)(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)$/;
  const isValid = typeof value === 'string' && urlPattern.test(value);
  return {
    valid: isValid,
    message: isValid ? undefined : '请输入有效的URL地址'
  };
}

/**
 * IP地址验证规则
 * @param {any} value - 要验证的值
 * @param {IpValidationOptions} [options] - IP地址验证选项
 * @param {string} [options.version] - IP地址版本，可选值：'v4'、'v6'、'v4v6'（默认为'v4v6'）
 * @returns {ValidationResult} 验证结果
 * @example
 * // 直接调用
 * const result1 = validateIp('192.168.1.1');
 * console.log(result1); // { valid: true, message: undefined }
 * 
 * // 验证IPv6
 * const result2 = validateIp('2001:0db8:85a3:0000:0000:8a2e:0370:7334', { version: 'v6' });
 * console.log(result2); // { valid: true, message: undefined }
 * 
 * // 使用validateRule
 * const ruleResult = validateRule('invalid-ip', { type: 'ip' });
 * console.log(ruleResult); // { valid: false, message: '请输入有效的IP地址' }
 */
export function validateIp(value: any, options: IpValidationOptions = {}): ValidationResult {
  if (value === undefined || value === null || value === '') {
    return {
      valid: false,
      message: '请输入IP地址'
    };
  }

  const ipString = String(value);
  let pattern: RegExp;

  if (options.version === 'v4') {
    // IPv4验证正则
    pattern = /^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
  } else if (options.version === 'v6') {
    // IPv6验证正则
    pattern = /^([0-9a-fA-F]{1,4}:){7}([0-9a-fA-F]{1,4})$/;
  } else {
    // 同时支持IPv4和IPv6
    pattern = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[0-9a-fA-F]{1,4}:){7}(?:[0-9a-fA-F]{1,4})$/;
  }

  const isValid = pattern.test(ipString);
  return {
    valid: isValid,
    message: isValid ? undefined : '请输入有效的IP地址'
  };
}

/**
 * 日期/时间验证规则
 * @param {any} value - 要验证的值
 * @returns {ValidationResult} 验证结果
 * 
 * @example
 * // 直接调用
 * const result1 = validateDateTime('2024-01-01');
 * console.log(result1); // { valid: true, message: undefined }
 * 
 * // 验证时间
 * const result2 = validateDateTime('12:30:45');
 * console.log(result2); // { valid: true, message: undefined }
 * 
 * // 验证日期时间
 * const result3 = validateDateTime('2024-01-01 12:30:45');
 * console.log(result3); // { valid: true, message: undefined }
 */
export function validateDateTime(value: any): ValidationResult {
  // 如果值为空，验证失败
  if (value === undefined || value === null || value === '') {
    return {
      valid: false,
      message: '请输入日期/时间'
    };
  }

  // 转换为字符串进行验证
  const dateString = String(value);

  // 尝试解析日期
  const date = dayjs(dateString);

  // 检查日期是否有效
  if (!date.isValid()) {
    return {
      valid: false,
      message: '请输入有效的日期/时间'
    };
  }

  // 验证通过
  return {
    valid: true,
    message: undefined
  };
}

/**
 * 正则表达式验证规则
 * 
 * @param {any} value - 要验证的值
 * @param {PatternValidationOptions} options - 正则表达式验证选项
 * @property {RegExp} options.pattern - 用于验证的正则表达式模式
 * @returns {ValidationResult} 验证结果
 * 
 * @example
 * // 直接调用
 * const result = validatePattern('123abc', { pattern: /^[a-zA-Z0-9]+$/ });
 * console.log(result); // { valid: true, message: undefined }
 * 
 * // 使用validateRule
 * const ruleResult = validateRule('123-abc', { type: 'pattern', options: { pattern: /^[a-zA-Z0-9]+$/ } });
 * console.log(ruleResult); // { valid: false, message: '格式不正确' }
 */
export function validatePattern(value: any, options: PatternValidationOptions): ValidationResult {
  const isValid = typeof value === 'string' && options.pattern.test(value);
  return {
    valid: isValid,
    message: isValid ? undefined : '格式不正确'
  };
}